package com.spc.car.data.service.sys.impl;

import com.baomidou.mybatisplus.core.conditions.query.QueryWrapper;
import com.spc.car.common.exception.CustomException;
import com.spc.car.data.constant.UserConstants;
import com.spc.car.data.entity.sys.SysRole;
import com.spc.car.data.mapper.sys.SysRoleMapper;
import com.spc.car.data.service.sys.SysRoleService;
import com.baomidou.mybatisplus.extension.service.impl.ServiceImpl;
import com.spc.car.data.service.sys.SysUserRoleService;
import org.apache.commons.lang3.StringUtils;
import org.springframework.beans.factory.annotation.Autowired;
import org.springframework.stereotype.Service;

import java.util.*;
import java.util.stream.Collectors;

/**
 * <p>
 * 角色信息表 服务实现类
 * </p>
 *
 * @author 
 * @since 2020-03-06
 */
@Service
public class SysRoleServiceImpl extends ServiceImpl<SysRoleMapper, SysRole> implements SysRoleService {

    @Autowired
    private SysUserRoleService sysUserRoleService;

    /**
     * 根据条件分页查询角色数据
     *
     * @param role 角色信息
     * @return 角色数据集合信息
     */
    @Override
    //@DataScope(deptAlias = "d")
    public List<SysRole> selectRoleList(SysRole role) {
        QueryWrapper condition = new QueryWrapper<SysRole>()
                .eq(StringUtils.isNotBlank(role.getStatus()), "status", role.getStatus())
                .like(StringUtils.isNotBlank(role.getRoleName()), "role_name", role.getRoleName())
                .like(StringUtils.isNotBlank(role.getRoleKey()), "role_key", role.getRoleKey());
        return list(condition);
    }

    /**
     * 根据用户ID查询权限
     *
     * @param userId 用户ID
     * @return 权限列表
     */
    @Override
    public Set<String> listPermissionByUserId(Long userId)
    {
        List<SysRole> roles = listRoleByUserId(userId);
        Set<String> permsSet = new HashSet<>();
        for (SysRole role : roles) {
            if (!Objects.isNull(role)) {
                permsSet.addAll(Arrays.asList(role.getRoleKey().trim().split(",")));
            }
        }
        return permsSet;
    }

    /**
     *
     * @param userId
     * @return
     */
    public List<SysRole> listRoleByUserId(Long userId) {
        return baseMapper.listRoleByUserId(userId);
    }

    /**
     * 查询所有角色
     *
     * @return 角色列表
     */
    public List<SysRole> selectRoleAll()
    {
        return list();
    }

    /**
     * 根据用户ID获取角色选择框列表
     *
     * @param userId 用户ID
     * @return 选中角色ID列表
     */
    public List<Long> listRoleIdByUserId(Long userId) {
        List<SysRole> roles = listRoleByUserId(userId);
        return roles.stream().map(SysRole::getRoleId).collect(Collectors.toList());
    }

    /**
     * 通过角色ID查询角色
     *
     * @param roleId 角色ID
     * @return 角色对象信息
     */
    public SysRole selectRoleById(Long roleId)
    {
        return getById(roleId);
    }

    /**
     * 校验角色名称是否唯一
     *
     * @param role 角色信息
     * @return 结果
     */
    @Override
    public String checkRoleNameUnique(SysRole role)
    {
        Long roleId = Objects.isNull(role.getRoleId()) ? -1L : role.getRoleId();
        SysRole info = getOne(new QueryWrapper<SysRole>().eq("role_name",role.getRoleName()));
        if (!Objects.isNull(info) && info.getRoleId().longValue() != roleId.longValue())
        {
            return UserConstants.NOT_UNIQUE;
        }
        return UserConstants.UNIQUE;
    }

    /**
     * 校验角色权限是否唯一
     *
     * @param role 角色信息
     * @return 结果
     */
    @Override
    public String checkRoleKeyUnique(SysRole role)
    {
        Long roleId = Objects.isNull(role.getRoleId()) ? -1L : role.getRoleId();
        SysRole info = getOne(new QueryWrapper<SysRole>().eq("role_key", role.getRoleKey()));
        if (!Objects.isNull(info) && info.getRoleId().longValue() != roleId.longValue())
        {
            return UserConstants.NOT_UNIQUE;
        }
        return UserConstants.UNIQUE;
    }

    /**
     * 校验角色是否允许操作
     *
     * @param role 角色信息
     */
    public void checkRoleAllowed(SysRole role)
    {
        if (!Objects.isNull(role.getRoleId()) && isAdmin(role.getRoleId())) {
            throw new CustomException("不允许操作超级管理员角色");
        }
    }

    /**
     * 修改角色状态
     *
     * @param role 角色信息
     * @return 结果
     */
    public int updateRoleStatus(SysRole role) {

        return baseMapper.update(new SysRole().setStatus(role.getStatus()),
                new QueryWrapper<SysRole>().eq("role_id", role.getRoleId()));
    }

    /**
     * 通过角色ID删除角色
     *
     * @param roleId 角色ID
     * @return 结果
     */
    @Override
    public int deleteRoleById(Long roleId) {
        return baseMapper.update(new SysRole().setDelFlag("1"), new QueryWrapper<SysRole>().eq("role_id", roleId));
    }

    /**
     * 批量删除角色信息
     *
     * @param roleIds 需要删除的角色ID
     * @return 结果
     */
    public int deleteRoleByIds(Long[] roleIds)
    {
        for (Long roleId : roleIds) {
            checkRoleAllowed(new SysRole().setRoleId(roleId));
            SysRole role = selectRoleById(roleId);
            if (sysUserRoleService.countUserByRoleId(roleId) > 0) {
                throw new CustomException(String.format("%1$s已分配,不能删除", role.getRoleName()));
            }
        }
        return baseMapper.update(new SysRole().setDelFlag("1"), new QueryWrapper<SysRole>().in("role_id", roleIds));
    }


    public boolean isAdmin(Long roleId)
    {
        return roleId != null && 1L == roleId;
    }
}
